"""
工作流管理路由模块
实现工作流创建、执行、查询等接口
"""

# 添加项目根目录到Python路径
import sys
import os
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

# 导入FastAPI相关组件
from fastapi import APIRouter, Depends, HTTPException, status
# 导入Pydantic模型用于数据验证
from pydantic import BaseModel
# 导入类型提示
from typing import List, Optional
# 导入日期时间处理模块
from datetime import datetime
# 导入SQLAlchemy会话
from sqlalchemy.orm import Session

# 导入模型和数据库会话
from utils.models import Workflow as WorkflowModel, WorkflowTemplate as WorkflowTemplateModel, WorkflowExecution as WorkflowExecutionModel, get_db

# 创建API路由实例
router = APIRouter(
    prefix="/api/v1/workflows",  # 路由前缀
    tags=["workflows"],  # 标签
    responses={404: {"description": "Not found"}},  # 响应定义
)

# 数据模型定义
class WorkflowNode(BaseModel):
    """
    工作流节点数据模型
    """
    id: str        # 节点ID
    type: str      # 节点类型
    position: dict # 节点位置
    data: dict     # 节点数据

class WorkflowEdge(BaseModel):
    """
    工作流边数据模型
    """
    id: str    # 边ID
    source: str # 源节点ID
    target: str # 目标节点ID
    type: str   # 边类型

class WorkflowBase(BaseModel):
    """
    工作流基础数据模型
    """
    name: str                    # 工作流名称
    description: Optional[str] = None  # 工作流描述
    nodes: List[WorkflowNode]    # 节点列表
    edges: List[WorkflowEdge]    # 边列表

class WorkflowCreate(WorkflowBase):
    """
    工作流创建数据模型
    """

class WorkflowUpdate(WorkflowBase):
    """
    工作流更新数据模型
    """

class Workflow(WorkflowBase):
    """
    工作流完整数据模型
    """
    id: int              # 工作流ID
    user_id: int         # 用户ID
    created_at: str      # 创建时间
    updated_at: str      # 更新时间

    class Config:
        from_attributes = True  # 启用ORM模式

class WorkflowResponse(BaseModel):
    """
    工作流响应数据模型
    """
    message: str              # 响应消息
    workflow: Optional[Workflow] = None  # 工作流数据

class WorkflowListResponse(BaseModel):
    """
    工作流列表响应数据模型
    """
    message: str                # 响应消息
    workflows: List[Workflow]   # 工作流列表

# 工作流模板数据模型
class WorkflowTemplateBase(BaseModel):
    """
    工作流模板基础数据模型
    """
    name: str                    # 模板名称
    description: Optional[str] = None  # 模板描述
    nodes: List[WorkflowNode]    # 节点列表
    edges: List[WorkflowEdge]    # 边列表
    is_public: Optional[int] = 0  # 是否公开模板

class WorkflowTemplateCreate(WorkflowTemplateBase):
    """
    工作流模板创建数据模型
    """

class WorkflowTemplateUpdate(WorkflowTemplateBase):
    """
    工作流模板更新数据模型
    """

class WorkflowTemplate(WorkflowTemplateBase):
    """
    工作流模板完整数据模型
    """
    id: int              # 模板ID
    user_id: int         # 用户ID
    created_at: str      # 创建时间
    updated_at: str      # 更新时间

    class Config:
        from_attributes = True  # 启用ORM模式

class WorkflowTemplateResponse(BaseModel):
    """
    工作流模板响应数据模型
    """
    message: str              # 响应消息
    template: Optional[WorkflowTemplate] = None  # 工作流模板数据

class WorkflowTemplateListResponse(BaseModel):
    """
    工作流模板列表响应数据模型
    """
    message: str                # 响应消息
    templates: List[WorkflowTemplate]   # 工作流模板列表

# 工作流执行历史数据模型
class WorkflowExecutionBase(BaseModel):
    """
    工作流执行基础数据模型
    """
    workflow_id: int                    # 关联的工作流ID
    status: Optional[str] = "pending"   # 执行状态
    started_at: Optional[datetime] = None  # 执行开始时间
    finished_at: Optional[datetime] = None # 执行结束时间
    logs: Optional[str] = None          # 执行日志
    result_data: Optional[str] = None   # 执行结果数据

class WorkflowExecutionCreate(WorkflowExecutionBase):
    """
    工作流执行创建数据模型
    """

class WorkflowExecutionUpdate(BaseModel):
    """
    工作流执行更新数据模型
    """
    status: Optional[str] = None        # 执行状态
    finished_at: Optional[datetime] = None # 执行结束时间
    logs: Optional[str] = None          # 执行日志
    result_data: Optional[str] = None   # 执行结果数据

class WorkflowExecution(WorkflowExecutionBase):
    """
    工作流执行完整数据模型
    """
    id: int              # 执行记录ID
    created_at: str      # 创建时间
    updated_at: str      # 更新时间

    class Config:
        from_attributes = True  # 启用ORM模式

class WorkflowExecutionResponse(BaseModel):
    """
    工作流执行响应数据模型
    """
    message: str              # 响应消息
    execution: Optional[WorkflowExecution] = None  # 工作流执行数据

class WorkflowExecutionListResponse(BaseModel):
    """
    工作流执行列表响应数据模型
    """
    message: str                # 响应消息
    executions: List[WorkflowExecution]   # 工作流执行列表

# 工作流服务类
class WorkflowService:
    """
    工作流服务类
    提供工作流相关的业务逻辑处理
    """
    
    @staticmethod
    def workflow_to_dict(workflow: WorkflowModel) -> dict:
        """
        将数据库工作流模型转换为字典
        Args:
            workflow (WorkflowModel): 数据库工作流模型
        Returns:
            dict: 工作流字典
        """
        return {
            "id": workflow.id,
            "name": workflow.name,
            "description": workflow.description,
            "nodes": json.loads(workflow.config).get("nodes", []),
            "edges": json.loads(workflow.config).get("edges", []),
            "user_id": workflow.user_id,
            "created_at": workflow.created_at.isoformat() if workflow.created_at else None,
            "updated_at": workflow.updated_at.isoformat() if workflow.updated_at else None
        }
    
    @staticmethod
    def template_to_dict(template: WorkflowTemplateModel) -> dict:
        """
        将数据库工作流模板模型转换为字典
        Args:
            template (WorkflowTemplateModel): 数据库工作流模板模型
        Returns:
            dict: 工作流模板字典
        """
        return {
            "id": template.id,
            "name": template.name,
            "description": template.description,
            "nodes": json.loads(template.config).get("nodes", []),
            "edges": json.loads(template.config).get("edges", []),
            "user_id": template.user_id,
            "is_public": template.is_public,
            "created_at": template.created_at.isoformat() if template.created_at else None,
            "updated_at": template.updated_at.isoformat() if template.updated_at else None
        }
    
    @staticmethod
    def execution_to_dict(execution: WorkflowExecutionModel) -> dict:
        """
        将数据库工作流执行模型转换为字典
        Args:
            execution (WorkflowExecutionModel): 数据库工作流执行模型
        Returns:
            dict: 工作流执行字典
        """
        return {
            "id": execution.id,
            "workflow_id": execution.workflow_id,
            "status": execution.status,
            "started_at": execution.started_at.isoformat() if execution.started_at else None,
            "finished_at": execution.finished_at.isoformat() if execution.finished_at else None,
            "logs": execution.logs,
            "result_data": execution.result_data,
            "created_at": execution.created_at.isoformat() if execution.created_at else None,
            "updated_at": execution.updated_at.isoformat() if execution.updated_at else None
        }
    
    @staticmethod
    def dict_to_workflow_config(data: dict) -> str:
        """
        将字典转换为工作流配置JSON字符串
        Args:
            data (dict): 包含nodes和edges的字典
        Returns:
            str: JSON格式的配置字符串
        """
        return json.dumps({
            "nodes": [node.dict() for node in data.get("nodes", [])],
            "edges": [edge.dict() for edge in data.get("edges", [])]
        })

# 路由定义
@router.get("/", response_model=WorkflowListResponse)
async def list_workflows(
    skip: int = 0, 
    limit: int = 100, 
    db: Session = Depends(get_db)
):
    """
    获取工作流列表接口
    从数据库获取工作流列表
    Args:
        skip (int): 跳过的记录数
        limit (int): 限制返回的记录数
        db (Session): 数据库会话
    Returns:
        WorkflowListResponse: 工作流列表响应
    """
    # 从数据库获取工作流列表
    workflows = db.query(WorkflowModel).offset(skip).limit(limit).all()
    
    # 转换为响应格式
    workflow_list = [Workflow(**WorkflowService.workflow_to_dict(w)) for w in workflows]
    
    return {
        "message": "工作流列表获取成功",
        "workflows": workflow_list
    }

@router.post("/", response_model=WorkflowResponse)
async def create_workflow(
    workflow: WorkflowCreate,
    user_id: int = 1,  # 实际项目中应从认证信息中获取
    db: Session = Depends(get_db)
):
    """
    创建工作流接口
    将工作流保存到数据库
    Args:
        workflow (WorkflowCreate): 工作流创建信息
        user_id (int): 用户ID
        db (Session): 数据库会话
    Returns:
        WorkflowResponse: 工作流响应
    """
    # 创建工作流记录
    db_workflow = WorkflowModel(
        name=workflow.name,
        description=workflow.description,
        config=WorkflowService.dict_to_workflow_config(workflow.dict()),
        user_id=user_id
    )
    
    # 保存到数据库
    db.add(db_workflow)
    db.commit()
    db.refresh(db_workflow)
    
    # 转换为响应格式
    workflow_dict = WorkflowService.workflow_to_dict(db_workflow)
    
    return {
        "message": "工作流创建成功",
        "workflow": Workflow(**workflow_dict)
    }

@router.get("/{workflow_id}", response_model=WorkflowResponse)
async def get_workflow(
    workflow_id: int,
    db: Session = Depends(get_db)
):
    """
    获取工作流详情接口
    从数据库获取指定工作流的详细信息
    Args:
        workflow_id (int): 工作流ID
        db (Session): 数据库会话
    Returns:
        WorkflowResponse: 工作流响应
    Raises:
        HTTPException: 当工作流未找到时抛出404异常
    """
    # 从数据库获取工作流
    db_workflow = db.query(WorkflowModel).filter(WorkflowModel.id == workflow_id).first()
    
    # 检查工作流是否存在
    if not db_workflow:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="工作流未找到"
        )
    
    # 转换为响应格式
    workflow_dict = WorkflowService.workflow_to_dict(db_workflow)
    
    return {
        "message": "工作流获取成功",
        "workflow": Workflow(**workflow_dict)
    }

@router.put("/{workflow_id}", response_model=WorkflowResponse)
async def update_workflow(
    workflow_id: int,
    workflow: WorkflowUpdate,
    db: Session = Depends(get_db)
):
    """
    更新工作流接口
    更新数据库中的工作流信息
    Args:
        workflow_id (int): 工作流ID
        workflow (WorkflowUpdate): 工作流更新信息
        db (Session): 数据库会话
    Returns:
        WorkflowResponse: 工作流响应
    Raises:
        HTTPException: 当工作流未找到时抛出404异常
    """
    # 从数据库获取工作流
    db_workflow = db.query(WorkflowModel).filter(WorkflowModel.id == workflow_id).first()
    
    # 检查工作流是否存在
    if not db_workflow:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="工作流未找到"
        )
    
    # 更新工作流信息
    db_workflow.name = workflow.name
    db_workflow.description = workflow.description
    db_workflow.config = WorkflowService.dict_to_workflow_config(workflow.dict())
    
    # 保存到数据库
    db.commit()
    db.refresh(db_workflow)
    
    # 转换为响应格式
    workflow_dict = WorkflowService.workflow_to_dict(db_workflow)
    
    return {
        "message": "工作流更新成功",
        "workflow": Workflow(**workflow_dict)
    }

@router.delete("/{workflow_id}")
async def delete_workflow(
    workflow_id: int,
    db: Session = Depends(get_db)
):
    """
    删除工作流接口
    从数据库中删除指定的工作流
    Args:
        workflow_id (int): 工作流ID
        db (Session): 数据库会话
    Returns:
        dict: 删除成功信息
    Raises:
        HTTPException: 当工作流未找到时抛出404异常
    """
    # 从数据库获取工作流
    db_workflow = db.query(WorkflowModel).filter(WorkflowModel.id == workflow_id).first()
    
    # 检查工作流是否存在
    if not db_workflow:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="工作流未找到"
        )
    
    # 从数据库删除工作流
    db.delete(db_workflow)
    db.commit()
    
    return {"message": f"工作流 {workflow_id} 已删除"}

# 工作流模板相关接口
@router.get("/templates/", response_model=WorkflowTemplateListResponse)
async def list_workflow_templates(
    skip: int = 0,
    limit: int = 100,
    is_public: Optional[int] = None,
    db: Session = Depends(get_db)
):
    """
    获取工作流模板列表接口
    从数据库获取工作流模板列表
    Args:
        skip (int): 跳过的记录数
        limit (int): 限制返回的记录数
        is_public (int): 是否公开模板（0-私有，1-公开）
        db (Session): 数据库会话
    Returns:
        WorkflowTemplateListResponse: 工作流模板列表响应
    """
    # 构建查询
    query = db.query(WorkflowTemplateModel)
    
    # 如果指定了公开状态，则按状态筛选
    if is_public is not None:
        query = query.filter(WorkflowTemplateModel.is_public == is_public)
    
    # 从数据库获取工作流模板列表
    templates = query.offset(skip).limit(limit).all()
    
    # 转换为响应格式
    template_list = [WorkflowTemplate(**WorkflowService.template_to_dict(t)) for t in templates]
    
    return {
        "message": "工作流模板列表获取成功",
        "templates": template_list
    }

@router.post("/templates/", response_model=WorkflowTemplateResponse)
async def create_workflow_template(
    template: WorkflowTemplateCreate,
    user_id: int = 1,  # 实际项目中应从认证信息中获取
    db: Session = Depends(get_db)
):
    """
    创建工作流模板接口
    将工作流模板保存到数据库
    Args:
        template (WorkflowTemplateCreate): 工作流模板创建信息
        user_id (int): 用户ID
        db (Session): 数据库会话
    Returns:
        WorkflowTemplateResponse: 工作流模板响应
    """
    # 创建工作流模板记录
    db_template = WorkflowTemplateModel(
        name=template.name,
        description=template.description,
        config=WorkflowService.dict_to_workflow_config(template.dict()),
        user_id=user_id,
        is_public=template.is_public
    )
    
    # 保存到数据库
    db.add(db_template)
    db.commit()
    db.refresh(db_template)
    
    # 转换为响应格式
    template_dict = WorkflowService.template_to_dict(db_template)
    
    return {
        "message": "工作流模板创建成功",
        "template": WorkflowTemplate(**template_dict)
    }

@router.get("/templates/{template_id}", response_model=WorkflowTemplateResponse)
async def get_workflow_template(
    template_id: int,
    db: Session = Depends(get_db)
):
    """
    获取工作流模板详情接口
    从数据库获取指定工作流模板的详细信息
    Args:
        template_id (int): 工作流模板ID
        db (Session): 数据库会话
    Returns:
        WorkflowTemplateResponse: 工作流模板响应
    Raises:
        HTTPException: 当工作流模板未找到时抛出404异常
    """
    # 从数据库获取工作流模板
    db_template = db.query(WorkflowTemplateModel).filter(WorkflowTemplateModel.id == template_id).first()
    
    # 检查工作流模板是否存在
    if not db_template:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="工作流模板未找到"
        )
    
    # 转换为响应格式
    template_dict = WorkflowService.template_to_dict(db_template)
    
    return {
        "message": "工作流模板获取成功",
        "template": WorkflowTemplate(**template_dict)
    }

@router.put("/templates/{template_id}", response_model=WorkflowTemplateResponse)
async def update_workflow_template(
    template_id: int,
    template: WorkflowTemplateUpdate,
    user_id: int = 1,  # 实际项目中应从认证信息中获取
    db: Session = Depends(get_db)
):
    """
    更新工作流模板接口
    更新数据库中的工作流模板信息
    Args:
        template_id (int): 工作流模板ID
        template (WorkflowTemplateUpdate): 工作流模板更新信息
        user_id (int): 用户ID
        db (Session): 数据库会话
    Returns:
        WorkflowTemplateResponse: 工作流模板响应
    Raises:
        HTTPException: 当工作流模板未找到时抛出404异常
    """
    # 从数据库获取工作流模板
    db_template = db.query(WorkflowTemplateModel).filter(WorkflowTemplateModel.id == template_id).first()
    
    # 检查工作流模板是否存在
    if not db_template:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="工作流模板未找到"
        )
    
    # 检查是否有权限更新（模板创建者或管理员）
    if db_template.user_id != user_id:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="无权限更新此模板"
        )
    
    # 更新工作流模板信息
    db_template.name = template.name
    db_template.description = template.description
    db_template.config = WorkflowService.dict_to_workflow_config(template.dict())
    db_template.is_public = template.is_public
    
    # 保存到数据库
    db.commit()
    db.refresh(db_template)
    
    # 转换为响应格式
    template_dict = WorkflowService.template_to_dict(db_template)
    
    return {
        "message": "工作流模板更新成功",
        "template": WorkflowTemplate(**template_dict)
    }

@router.delete("/templates/{template_id}")
async def delete_workflow_template(
    template_id: int,
    user_id: int = 1,  # 实际项目中应从认证信息中获取
    db: Session = Depends(get_db)
):
    """
    删除工作流模板接口
    从数据库中删除指定的工作流模板
    Args:
        template_id (int): 工作流模板ID
        user_id (int): 用户ID
        db (Session): 数据库会话
    Returns:
        dict: 删除成功信息
    Raises:
        HTTPException: 当工作流模板未找到时抛出404异常
    """
    # 从数据库获取工作流模板
    db_template = db.query(WorkflowTemplateModel).filter(WorkflowTemplateModel.id == template_id).first()
    
    # 检查工作流模板是否存在
    if not db_template:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="工作流模板未找到"
        )
    
    # 检查是否有权限删除（模板创建者或管理员）
    if db_template.user_id != user_id:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="无权限删除此模板"
        )
    
    # 从数据库删除工作流模板
    db.delete(db_template)
    db.commit()
    
    return {"message": f"工作流模板 {template_id} 已删除"}

# 工作流执行历史相关接口
@router.get("/executions/", response_model=WorkflowExecutionListResponse)
async def list_workflow_executions(
    skip: int = 0,
    limit: int = 100,
    workflow_id: Optional[int] = None,
    status: Optional[str] = None,
    db: Session = Depends(get_db)
):
    """
    获取工作流执行历史列表接口
    从数据库获取工作流执行历史列表
    Args:
        skip (int): 跳过的记录数
        limit (int): 限制返回的记录数
        workflow_id (int): 工作流ID筛选
        status (str): 执行状态筛选
        db (Session): 数据库会话
    Returns:
        WorkflowExecutionListResponse: 工作流执行历史列表响应
    """
    # 构建查询
    query = db.query(WorkflowExecutionModel)
    
    # 如果指定了工作流ID，则按工作流ID筛选
    if workflow_id is not None:
        query = query.filter(WorkflowExecutionModel.workflow_id == workflow_id)
    
    # 如果指定了状态，则按状态筛选
    if status is not None:
        query = query.filter(WorkflowExecutionModel.status == status)
    
    # 从数据库获取工作流执行历史列表
    executions = query.offset(skip).limit(limit).all()
    
    # 转换为响应格式
    execution_list = [WorkflowExecution(**WorkflowService.execution_to_dict(e)) for e in executions]
    
    return {
        "message": "工作流执行历史列表获取成功",
        "executions": execution_list
    }

@router.post("/executions/", response_model=WorkflowExecutionResponse)
async def create_workflow_execution(
    execution: WorkflowExecutionCreate,
    db: Session = Depends(get_db)
):
    """
    创建工作流执行记录接口
    将工作流执行记录保存到数据库
    Args:
        execution (WorkflowExecutionCreate): 工作流执行记录创建信息
        db (Session): 数据库会话
    Returns:
        WorkflowExecutionResponse: 工作流执行记录响应
    """
    # 创建工作流执行记录
    db_execution = WorkflowExecutionModel(
        workflow_id=execution.workflow_id,
        status=execution.status,
        started_at=execution.started_at,
        finished_at=execution.finished_at,
        logs=execution.logs,
        result_data=execution.result_data
    )
    
    # 保存到数据库
    db.add(db_execution)
    db.commit()
    db.refresh(db_execution)
    
    # 转换为响应格式
    execution_dict = WorkflowService.execution_to_dict(db_execution)
    
    return {
        "message": "工作流执行记录创建成功",
        "execution": WorkflowExecution(**execution_dict)
    }

@router.get("/executions/{execution_id}", response_model=WorkflowExecutionResponse)
async def get_workflow_execution(
    execution_id: int,
    db: Session = Depends(get_db)
):
    """
    获取工作流执行记录详情接口
    从数据库获取指定工作流执行记录的详细信息
    Args:
        execution_id (int): 工作流执行记录ID
        db (Session): 数据库会话
    Returns:
        WorkflowExecutionResponse: 工作流执行记录响应
    Raises:
        HTTPException: 当工作流执行记录未找到时抛出404异常
    """
    # 从数据库获取工作流执行记录
    db_execution = db.query(WorkflowExecutionModel).filter(WorkflowExecutionModel.id == execution_id).first()
    
    # 检查工作流执行记录是否存在
    if not db_execution:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="工作流执行记录未找到"
        )
    
    # 转换为响应格式
    execution_dict = WorkflowService.execution_to_dict(db_execution)
    
    return {
        "message": "工作流执行记录获取成功",
        "execution": WorkflowExecution(**execution_dict)
    }

@router.put("/executions/{execution_id}", response_model=WorkflowExecutionResponse)
async def update_workflow_execution(
    execution_id: int,
    execution: WorkflowExecutionUpdate,
    db: Session = Depends(get_db)
):
    """
    更新工作流执行记录接口
    更新数据库中的工作流执行记录信息
    Args:
        execution_id (int): 工作流执行记录ID
        execution (WorkflowExecutionUpdate): 工作流执行记录更新信息
        db (Session): 数据库会话
    Returns:
        WorkflowExecutionResponse: 工作流执行记录响应
    Raises:
        HTTPException: 当工作流执行记录未找到时抛出404异常
    """
    # 从数据库获取工作流执行记录
    db_execution = db.query(WorkflowExecutionModel).filter(WorkflowExecutionModel.id == execution_id).first()
    
    # 检查工作流执行记录是否存在
    if not db_execution:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="工作流执行记录未找到"
        )
    
    # 更新工作流执行记录信息
    if execution.status is not None:
        db_execution.status = execution.status
    if execution.finished_at is not None:
        db_execution.finished_at = execution.finished_at
    if execution.logs is not None:
        db_execution.logs = execution.logs
    if execution.result_data is not None:
        db_execution.result_data = execution.result_data
    
    # 保存到数据库
    db.commit()
    db.refresh(db_execution)
    
    # 转换为响应格式
    execution_dict = WorkflowService.execution_to_dict(db_execution)
    
    return {
        "message": "工作流执行记录更新成功",
        "execution": WorkflowExecution(**execution_dict)
    }

@router.delete("/executions/{execution_id}")
async def delete_workflow_execution(
    execution_id: int,
    db: Session = Depends(get_db)
):
    """
    删除工作流执行记录接口
    从数据库中删除指定的工作流执行记录
    Args:
        execution_id (int): 工作流执行记录ID
        db (Session): 数据库会话
    Returns:
        dict: 删除成功信息
    Raises:
        HTTPException: 当工作流执行记录未找到时抛出404异常
    """
    # 从数据库获取工作流执行记录
    db_execution = db.query(WorkflowExecutionModel).filter(WorkflowExecutionModel.id == execution_id).first()
    
    # 检查工作流执行记录是否存在
    if not db_execution:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="工作流执行记录未找到"
        )
    
    # 从数据库删除工作流执行记录
    db.delete(db_execution)
    db.commit()
    
    return {"message": f"工作流执行记录 {execution_id} 已删除"}